/* tell the clipboard manager to make the data persistent */
clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
- gtk_clipboard_set_can_store (clipboard, NULL, 0);
+ gtk_clipboard_set_can_store (clipboard, NULL);
}
if (!gtk_widget_get_visible (window))
gtk_target_list_unref
gtk_target_list_add
gtk_target_list_add_table
+gtk_target_list_merge
gtk_target_list_add_text_targets
gtk_target_list_add_image_targets
gtk_target_list_add_uri_targets
#include "gtkinvisible.h"
#include "gtkmain.h"
#include "gtkmarshalers.h"
+#include "gtkselectionprivate.h"
#include "gtktextbufferrichtext.h"
#include "gtkintl.h"
static void gtk_clipboard_owner_change (GtkClipboard *clipboard,
GdkEventOwnerChange *event);
static gboolean gtk_clipboard_set_contents (GtkClipboard *clipboard,
- const GtkTargetEntry *targets,
- guint n_targets,
+ GtkTargetList *targets,
GtkClipboardGetFunc get_func,
GtkClipboardClearFunc clear_func,
gpointer user_data,
GtkClipboardReceivedFunc callback,
gpointer user_data);
static void gtk_clipboard_real_set_can_store (GtkClipboard *clipboard,
- const GtkTargetEntry *targets,
- gint n_targets);
+ GtkTargetList *targets);
static void gtk_clipboard_real_store (GtkClipboard *clipboard);
static gboolean
gtk_clipboard_set_contents (GtkClipboard *clipboard,
- const GtkTargetEntry *targets,
- guint n_targets,
+ GtkTargetList *targets,
GtkClipboardGetFunc get_func,
GtkClipboardClearFunc clear_func,
gpointer user_data,
clipboard->clear_func = clear_func;
gtk_selection_clear_targets (clipboard_widget, clipboard->selection);
- gtk_selection_add_targets (clipboard_widget, clipboard->selection,
- targets, n_targets);
+ gtk_selection_add_targets (clipboard_widget, clipboard->selection, targets);
return TRUE;
}
/**
* gtk_clipboard_set_with_data: (skip)
* @clipboard: a #GtkClipboard
- * @targets: (array length=n_targets): array containing information
- * about the available forms for the clipboard data
- * @n_targets: number of elements in @targets
+ * @targets: The targets (data formats) in which the
+ * functions can provide the data
* @get_func: (scope async): function to call to get the actual clipboard data
* @clear_func: (scope async): when the clipboard contents are set again,
* this function will be called, and @get_func will not be subsequently
**/
gboolean
gtk_clipboard_set_with_data (GtkClipboard *clipboard,
- const GtkTargetEntry *targets,
- guint n_targets,
+ GtkTargetList *targets,
GtkClipboardGetFunc get_func,
GtkClipboardClearFunc clear_func,
gpointer user_data)
return GTK_CLIPBOARD_GET_CLASS (clipboard)->set_contents (clipboard,
targets,
- n_targets,
get_func,
clear_func,
user_data,
/**
* gtk_clipboard_set_with_owner: (skip)
* @clipboard: a #GtkClipboard
- * @targets: (array length=n_targets): array containing information
- * about the available forms for the clipboard data
- * @n_targets: number of elements in @targets
+ * @targets: The targets (data formats) in which the
+ * functions can provide the data
* @get_func: (scope async): function to call to get the actual clipboard data
* @clear_func: (scope async): when the clipboard contents are set again,
* this function will be called, and @get_func will not be subsequently
**/
gboolean
gtk_clipboard_set_with_owner (GtkClipboard *clipboard,
- const GtkTargetEntry *targets,
- guint n_targets,
+ GtkTargetList *targets,
GtkClipboardGetFunc get_func,
GtkClipboardClearFunc clear_func,
GObject *owner)
return GTK_CLIPBOARD_GET_CLASS (clipboard)->set_contents (clipboard,
targets,
- n_targets,
get_func,
clear_func,
owner,
const gchar *text,
gint len)
{
- GtkTargetList *list;
- GtkTargetEntry *targets;
- gint n_targets;
+ GtkTargetList *targets;
g_return_if_fail (clipboard != NULL);
g_return_if_fail (text != NULL);
- list = gtk_target_list_new (NULL, 0);
- gtk_target_list_add_text_targets (list, 0);
+ targets = gtk_target_list_new (NULL, 0);
+ gtk_target_list_add_text_targets (targets, 0);
- targets = gtk_target_table_new_from_list (list, &n_targets);
-
if (len < 0)
len = strlen (text);
gtk_clipboard_set_with_data (clipboard,
- targets, n_targets,
+ targets,
text_get_func, text_clear_func,
g_strndup (text, len));
- gtk_clipboard_set_can_store (clipboard, NULL, 0);
+ gtk_clipboard_set_can_store (clipboard, NULL);
- gtk_target_table_free (targets, n_targets);
- gtk_target_list_unref (list);
+ gtk_target_list_unref (targets);
}
static void
gtk_clipboard_set_image (GtkClipboard *clipboard,
GdkPixbuf *pixbuf)
{
- GtkTargetList *list;
- GtkTargetEntry *targets;
- gint n_targets;
+ GtkTargetList *targets;
g_return_if_fail (clipboard != NULL);
g_return_if_fail (GDK_IS_PIXBUF (pixbuf));
- list = gtk_target_list_new (NULL, 0);
- gtk_target_list_add_image_targets (list, 0, TRUE);
-
- targets = gtk_target_table_new_from_list (list, &n_targets);
+ targets = gtk_target_list_new (NULL, 0);
+ gtk_target_list_add_image_targets (targets, 0, TRUE);
gtk_clipboard_set_with_data (clipboard,
- targets, n_targets,
+ targets,
pixbuf_get_func, pixbuf_clear_func,
g_object_ref (pixbuf));
- gtk_clipboard_set_can_store (clipboard, NULL, 0);
+ gtk_clipboard_set_can_store (clipboard, NULL);
- gtk_target_table_free (targets, n_targets);
- gtk_target_list_unref (list);
+ gtk_target_list_unref (targets);
}
/**
/**
* gtk_clipboard_set_can_store:
* @clipboard: a #GtkClipboard
- * @targets: (allow-none) (array length=n_targets): array containing
- * information about which forms should be stored or %NULL
- * to indicate that all forms should be stored.
+ * @targets: (allow-none): The targets (data formats) in which the
+ * functions can provide the data or %NULL
+ * to indicate that all forms should be stored.
* @n_targets: number of elements in @targets
*
* Hints that the clipboard data should be stored somewhere when the
* Since: 2.6
*/
void
-gtk_clipboard_set_can_store (GtkClipboard *clipboard,
- const GtkTargetEntry *targets,
- gint n_targets)
+gtk_clipboard_set_can_store (GtkClipboard *clipboard,
+ GtkTargetList *targets)
{
g_return_if_fail (GTK_IS_CLIPBOARD (clipboard));
- g_return_if_fail (n_targets >= 0);
- GTK_CLIPBOARD_GET_CLASS (clipboard)->set_can_store (clipboard,
- targets,
- n_targets);
+ GTK_CLIPBOARD_GET_CLASS (clipboard)->set_can_store (clipboard, targets);
}
static void
-gtk_clipboard_real_set_can_store (GtkClipboard *clipboard,
- const GtkTargetEntry *targets,
- gint n_targets)
+gtk_clipboard_real_set_can_store (GtkClipboard *clipboard,
+ GtkTargetList *targets)
{
GtkWidget *clipboard_widget;
- int i;
- static const GtkTargetEntry save_targets[] = {
- { (char *) "SAVE_TARGETS", 0, TARGET_SAVE_TARGETS }
- };
-
+ guint n_atoms;
+
if (clipboard->selection != GDK_SELECTION_CLIPBOARD)
return;
*/
if (clipboard->n_storable_targets == -1)
{
- gtk_selection_add_targets (clipboard_widget, clipboard->selection,
- save_targets, 1);
+ gtk_selection_add_target (clipboard_widget,
+ clipboard->selection,
+ gdk_atom_intern_static_string ("SAVE_TARGETS"),
+ TARGET_SAVE_TARGETS);
/* Ref the owner so it won't go away */
if (clipboard->have_owner)
g_object_ref (clipboard->user_data);
}
- clipboard->n_storable_targets = n_targets;
- clipboard->storable_targets = g_new (GdkAtom, n_targets);
- for (i = 0; i < n_targets; i++)
- clipboard->storable_targets[i] = gdk_atom_intern (targets[i].target, FALSE);
+ if (targets)
+ {
+ clipboard->storable_targets = gtk_target_list_get_atoms (targets, &n_atoms);
+ clipboard->n_storable_targets = n_atoms;
+ }
+ else
+ {
+ clipboard->storable_targets = NULL;
+ clipboard->n_storable_targets = 0;
+ }
}
static gboolean
GDK_AVAILABLE_IN_ALL
gboolean gtk_clipboard_set_with_data (GtkClipboard *clipboard,
- const GtkTargetEntry *targets,
- guint n_targets,
+ GtkTargetList *targets,
GtkClipboardGetFunc get_func,
GtkClipboardClearFunc clear_func,
gpointer user_data);
GDK_AVAILABLE_IN_ALL
gboolean gtk_clipboard_set_with_owner (GtkClipboard *clipboard,
- const GtkTargetEntry *targets,
- guint n_targets,
+ GtkTargetList *targets,
GtkClipboardGetFunc get_func,
GtkClipboardClearFunc clear_func,
GObject *owner);
GDK_AVAILABLE_IN_ALL
void gtk_clipboard_set_can_store (GtkClipboard *clipboard,
- const GtkTargetEntry *targets,
- gint n_targets);
+ GtkTargetList *targets);
GDK_AVAILABLE_IN_ALL
void gtk_clipboard_store (GtkClipboard *clipboard);
/* vfuncs */
gboolean (* set_contents) (GtkClipboard *clipboard,
- const GtkTargetEntry *targets,
- guint n_targets,
+ GtkTargetList *targets,
GtkClipboardGetFunc get_func,
GtkClipboardClearFunc clear_func,
gpointer user_data,
GtkClipboardReceivedFunc callback,
gpointer user_data);
void (* set_can_store) (GtkClipboard *clipboard,
- const GtkTargetEntry *targets,
- gint n_targets);
+ GtkTargetList *targets);
void (* store) (GtkClipboard *clipboard);
/* signals */
gtk_entry_update_primary_selection (GtkEntry *entry)
{
GtkTargetList *list;
- GtkTargetEntry *targets;
GtkClipboard *clipboard;
gint start, end;
- gint n_targets;
if (!gtk_widget_get_realized (GTK_WIDGET (entry)))
return;
list = gtk_target_list_new (NULL, 0);
gtk_target_list_add_text_targets (list, 0);
- targets = gtk_target_table_new_from_list (list, &n_targets);
-
clipboard = gtk_widget_get_clipboard (GTK_WIDGET (entry), GDK_SELECTION_PRIMARY);
if (gtk_editable_get_selection_bounds (GTK_EDITABLE (entry), &start, &end))
{
- gtk_clipboard_set_with_owner (clipboard, targets, n_targets,
+ gtk_clipboard_set_with_owner (clipboard, list,
primary_get_cb, primary_clear_cb, G_OBJECT (entry));
}
else
gtk_clipboard_clear (clipboard);
}
- gtk_target_table_free (targets, n_targets);
gtk_target_list_unref (list);
}
{
GtkClipboard *clipboard;
GtkTargetList *target_list;
- GtkTargetEntry *targets;
- int n_targets;
clipboard = gtk_widget_get_clipboard (GTK_WIDGET (impl), GDK_SELECTION_CLIPBOARD);
gtk_target_list_add_text_targets (target_list, SELECTION_TEXT);
gtk_target_list_add_uri_targets (target_list, SELECTION_URI);
- targets = gtk_target_table_new_from_list (target_list, &n_targets);
- gtk_target_list_unref (target_list);
-
- gtk_clipboard_set_with_data (clipboard, targets, n_targets,
+ gtk_clipboard_set_with_data (clipboard, target_list,
copy_file_get_cb,
copy_file_clear_cb,
selected_files);
- gtk_target_table_free (targets, n_targets);
+ gtk_target_list_unref (target_list);
}
}
if (anchor_index != end_index)
{
GtkTargetList *list;
- GtkTargetEntry *targets;
- gint n_targets;
list = gtk_target_list_new (NULL, 0);
gtk_target_list_add_text_targets (list, 0);
- targets = gtk_target_table_new_from_list (list, &n_targets);
if (clipboard)
gtk_clipboard_set_with_owner (clipboard,
- targets, n_targets,
+ list,
get_text_callback,
clear_text_callback,
G_OBJECT (label));
- gtk_target_table_free (targets, n_targets);
gtk_target_list_unref (list);
if (!priv->select_info->selection_node)
gtk_target_list_add (list, text_uri_list_atom, 0, info);
}
+/**
+ * gtk_target_list_merge:
+ * @target: the #GtkTargetList to merge into
+ * @source: the #GtkTargeList to merge from
+ *
+ * Merges all targets from @source into @target.
+ */
+void
+gtk_target_list_merge (GtkTargetList *target,
+ const GtkTargetList *source)
+{
+ GList *l;
+
+ g_return_if_fail (target != NULL);
+ g_return_if_fail (source != NULL);
+
+ for (l = source->list; l; l = l->next)
+ {
+ target->list = g_list_prepend (target->list, g_slice_dup (GtkTargetPair, l->data));
+ }
+}
+
/**
* gtk_target_list_add_table:
* @list: a #GtkTargetList
return FALSE;
}
+GdkAtom *
+gtk_target_list_get_atoms (GtkTargetList *list,
+ guint *n_atoms)
+{
+ GdkAtom *atoms;
+ GList *l;
+ guint i, n;
+
+ n = g_list_length (list->list);
+ atoms = g_new (GdkAtom, n);
+
+ i = 0;
+ for (l = list->list; l; l = l->next)
+ atoms[i++] = ((GtkTargetPair *) l->data)->target;
+
+ if (n_atoms)
+ *n_atoms = n;
+
+ return atoms;
+}
+
/**
* gtk_target_table_new_from_list:
* @list: a #GtkTargetList
* for a given widget and selection.
**/
void
-gtk_selection_add_targets (GtkWidget *widget,
- GdkAtom selection,
- const GtkTargetEntry *targets,
- guint ntargets)
+gtk_selection_add_targets (GtkWidget *widget,
+ GdkAtom selection,
+ GtkTargetList *targets)
{
GtkTargetList *list;
- GdkAtom *atoms = g_new (GdkAtom, ntargets);
- guint i;
+ GdkAtom *atoms;
+ guint n_targets;
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (selection != GDK_NONE);
g_return_if_fail (targets != NULL);
list = gtk_selection_target_list_get (widget, selection);
- gtk_target_list_add_table (list, targets, ntargets);
-
- for (i = 0; i < ntargets; i++)
- atoms[i] = gdk_atom_intern (targets[i].target, FALSE);
+ gtk_target_list_merge (list, targets);
- gdk_selection_add_targets (gtk_widget_get_window (widget), selection, atoms, ntargets);
+ atoms = gtk_target_list_get_atoms (targets, &n_targets);
+ gdk_selection_add_targets (gtk_widget_get_window (widget), selection, atoms, n_targets);
g_free (atoms);
}
GtkTargetList *gtk_target_list_ref (GtkTargetList *list);
GDK_AVAILABLE_IN_ALL
void gtk_target_list_unref (GtkTargetList *list);
+GDK_AVAILABLE_IN_3_94
+void gtk_target_list_merge (GtkTargetList *target,
+ const GtkTargetList *source);
GDK_AVAILABLE_IN_ALL
void gtk_target_list_add (GtkTargetList *list,
GdkAtom target,
GDK_AVAILABLE_IN_ALL
void gtk_selection_add_targets (GtkWidget *widget,
GdkAtom selection,
- const GtkTargetEntry *targets,
- guint ntargets);
+ GtkTargetList *targets);
GDK_AVAILABLE_IN_ALL
void gtk_selection_clear_targets (GtkWidget *widget,
GdkAtom selection);
guint ref_count;
};
+GdkAtom *gtk_target_list_get_atoms (GtkTargetList *targets,
+ guint *n_atoms);
+
gboolean _gtk_selection_clear (GtkWidget *widget,
GdkEventSelection *event);
gboolean _gtk_selection_request (GtkWidget *widget,
struct _GtkTextBufferPrivate
{
GtkTargetList *copy_target_list;
- GtkTargetEntry *copy_target_entries;
GtkTargetList *paste_target_list;
- GtkTargetEntry *paste_target_entries;
-
- gint n_copy_target_entries;
- gint n_paste_target_entries;
GtkTextTagTable *tag_table;
GtkTextBTree *btree;
* timestamp.
*/
gtk_clipboard_set_with_owner (clipboard,
- priv->copy_target_entries,
- priv->n_copy_target_entries,
+ priv->copy_target_list,
clipboard_get_selection_cb,
clipboard_clear_selection_cb,
G_OBJECT (buffer));
return retval;
}
+static void
+gtk_text_buffer_free_target_lists (GtkTextBuffer *buffer)
+{
+ GtkTextBufferPrivate *priv = buffer->priv;
+
+ g_clear_pointer (&priv->copy_target_list, gtk_target_list_unref);
+ g_clear_pointer (&priv->paste_target_list, gtk_target_list_unref);
+}
+
+static GtkTargetList *
+gtk_text_buffer_get_target_list (GtkTextBuffer *buffer,
+ gboolean deserializable,
+ gboolean include_local)
+{
+ GtkTargetList *target_list;
+
+ target_list = gtk_target_list_new (NULL, 0);
+
+ if (include_local)
+ gtk_target_list_add (target_list,
+ gdk_atom_intern_static_string ("GTK_TEXT_BUFFER_CONTENTS"),
+ GTK_TARGET_SAME_APP,
+ GTK_TEXT_BUFFER_TARGET_INFO_BUFFER_CONTENTS);
+
+ gtk_target_list_add_rich_text_targets (target_list,
+ GTK_TEXT_BUFFER_TARGET_INFO_RICH_TEXT,
+ deserializable,
+ buffer);
+
+ gtk_target_list_add_text_targets (target_list,
+ GTK_TEXT_BUFFER_TARGET_INFO_TEXT);
+
+ return target_list;
+}
+
static void
cut_or_copy (GtkTextBuffer *buffer,
GtkClipboard *clipboard,
gtk_text_buffer_insert_range (contents, &ins, &start, &end);
if (!gtk_clipboard_set_with_data (clipboard,
- priv->copy_target_entries,
- priv->n_copy_target_entries,
+ priv->copy_target_list,
clipboard_get_contents_cb,
clipboard_clear_contents_cb,
contents))
- g_object_unref (contents);
+ {
+ g_object_unref (contents);
+ }
else
- gtk_clipboard_set_can_store (clipboard,
- priv->copy_target_entries + 1,
- priv->n_copy_target_entries - 1);
+ {
+ GtkTargetList *list;
+
+ list = gtk_text_buffer_get_target_list (buffer, FALSE, FALSE);
+ gtk_clipboard_set_can_store (clipboard, list);
+ gtk_target_list_unref (list);
+ }
if (delete_region_after)
{
}
}
-static void
-gtk_text_buffer_free_target_lists (GtkTextBuffer *buffer)
-{
- GtkTextBufferPrivate *priv = buffer->priv;
-
- if (priv->copy_target_list)
- {
- gtk_target_list_unref (priv->copy_target_list);
- priv->copy_target_list = NULL;
-
- gtk_target_table_free (priv->copy_target_entries,
- priv->n_copy_target_entries);
- priv->copy_target_entries = NULL;
- priv->n_copy_target_entries = 0;
- }
-
- if (priv->paste_target_list)
- {
- gtk_target_list_unref (priv->paste_target_list);
- priv->paste_target_list = NULL;
-
- gtk_target_table_free (priv->paste_target_entries,
- priv->n_paste_target_entries);
- priv->paste_target_entries = NULL;
- priv->n_paste_target_entries = 0;
- }
-}
-
-static GtkTargetList *
-gtk_text_buffer_get_target_list (GtkTextBuffer *buffer,
- gboolean deserializable,
- GtkTargetEntry **entries,
- gint *n_entries)
-{
- GtkTargetList *target_list;
-
- target_list = gtk_target_list_new (NULL, 0);
-
- gtk_target_list_add (target_list,
- gdk_atom_intern_static_string ("GTK_TEXT_BUFFER_CONTENTS"),
- GTK_TARGET_SAME_APP,
- GTK_TEXT_BUFFER_TARGET_INFO_BUFFER_CONTENTS);
-
- gtk_target_list_add_rich_text_targets (target_list,
- GTK_TEXT_BUFFER_TARGET_INFO_RICH_TEXT,
- deserializable,
- buffer);
-
- gtk_target_list_add_text_targets (target_list,
- GTK_TEXT_BUFFER_TARGET_INFO_TEXT);
-
- *entries = gtk_target_table_new_from_list (target_list, n_entries);
-
- return target_list;
-}
-
/**
* gtk_text_buffer_get_copy_target_list:
* @buffer: a #GtkTextBuffer
if (! priv->copy_target_list)
priv->copy_target_list =
- gtk_text_buffer_get_target_list (buffer, FALSE,
- &priv->copy_target_entries,
- &priv->n_copy_target_entries);
+ gtk_text_buffer_get_target_list (buffer, FALSE, TRUE);
return priv->copy_target_list;
}
if (! priv->paste_target_list)
priv->paste_target_list =
- gtk_text_buffer_get_target_list (buffer, TRUE,
- &priv->paste_target_entries,
- &priv->n_paste_target_entries);
+ gtk_text_buffer_get_target_list (buffer, TRUE, TRUE);
return priv->paste_target_list;
}
{ "COMPOUND_TEXT", 0, COMPOUND_TEXT }
};
static gint ntargets = sizeof(targetlist) / sizeof(targetlist[0]);
+ GtkTargetList *list;
gtk_init ();
g_signal_connect (selection_widget, "selection_received",
G_CALLBACK (selection_received), NULL);
- gtk_selection_add_targets (selection_widget, GDK_SELECTION_PRIMARY,
- targetlist, ntargets);
+ list = gtk_target_list_new (targetlist, ntargets);
+ gtk_selection_add_targets (selection_widget, GDK_SELECTION_PRIMARY, list);
+ gtk_target_list_unref (list);
g_signal_connect (selection_widget, "selection_get",
G_CALLBACK (selection_get), NULL);
{
GtkClipboard *clipboard = gtk_clipboard_get_for_display (gdk_display_get_default (), GDK_SELECTION_CLIPBOARD);
GtkTargetEntry entries[] = { { .target = TARGET_TEXT, .info = 42 } };
+ GtkTargetList *targets;
- gtk_clipboard_set_with_data (clipboard, entries, G_N_ELEMENTS(entries), test_with_data_get, NULL, NULL);
+ targets = gtk_target_list_new (entries, G_N_ELEMENTS(entries));
+ gtk_clipboard_set_with_data (clipboard, targets, test_with_data_get, NULL, NULL);
+ gtk_target_list_unref (targets);
gtk_clipboard_request_contents (clipboard, gdk_atom_intern (TARGET_TEXT, FALSE), test_with_data_got, NULL);
}
projects / gtk4.git / commitdiff